// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file is a clone of "base/optional.h" in chromium.
// Keep in sync, especially when fixing bugs.
// Copyright 2017 the V8 project authors. All rights reserved.

#ifndef V8_BASE_OPTIONAL_H_
#define V8_BASE_OPTIONAL_H_

#include <type_traits>
#include <utility>

#include "src/base/logging.h"

namespace v8 {
namespace base {

    // Specification:
    // http://en.cppreference.com/w/cpp/utility/optional/in_place_t
    struct in_place_t {
    };

    // Specification:
    // http://en.cppreference.com/w/cpp/utility/optional/nullopt_t
    struct nullopt_t {
        constexpr explicit nullopt_t(int) { }
    };

    // Specification:
    // http://en.cppreference.com/w/cpp/utility/optional/in_place
    constexpr in_place_t in_place = {};

    // Specification:
    // http://en.cppreference.com/w/cpp/utility/optional/nullopt
    constexpr nullopt_t nullopt(0);

    // Forward declaration, which is refered by following helpers.
    template <typename T>
    class Optional;

    namespace internal {

        template <typename T, bool = std::is_trivially_destructible<T>::value>
        struct OptionalStorageBase {
            // Initializing |empty_| here instead of using default member initializing
            // to avoid errors in g++ 4.8.
            constexpr OptionalStorageBase()
                : empty_('\0')
            {
            }

            template <class... Args>
            constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
                : is_populated_(true)
                , value_(std::forward<Args>(args)...)
            {
            }

            // When T is not trivially destructible we must call its
            // destructor before deallocating its memory.
            // Note that this hides the (implicitly declared) move constructor, which
            // would be used for constexpr move constructor in OptionalStorage<T>.
            // It is needed iff T is trivially move constructible. However, the current
            // is_trivially_{copy,move}_constructible implementation requires
            // is_trivially_destructible (which looks a bug, cf:
            // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452 and
            // http://cplusplus.github.io/LWG/lwg-active.html#2116), so it is not
            // necessary for this case at the moment. Please see also the destructor
            // comment in "is_trivially_destructible = true" specialization below.
            ~OptionalStorageBase()
            {
                if (is_populated_)
                    value_.~T();
            }

            template <class... Args>
            void Init(Args&&... args)
            {
                DCHECK(!is_populated_);
                ::new (&value_) T(std::forward<Args>(args)...);
                is_populated_ = true;
            }

            bool is_populated_ = false;
            union {
                // |empty_| exists so that the union will always be initialized, even when
                // it doesn't contain a value. Union members must be initialized for the
                // constructor to be 'constexpr'.
                char empty_;
                T value_;
            };
        };

        template <typename T>
        struct OptionalStorageBase<T, true /* trivially destructible */> {
            // Initializing |empty_| here instead of using default member initializing
            // to avoid errors in g++ 4.8.
            constexpr OptionalStorageBase()
                : empty_('\0')
            {
            }

            template <class... Args>
            constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
                : is_populated_(true)
                , value_(std::forward<Args>(args)...)
            {
            }

            // When T is trivially destructible (i.e. its destructor does nothing) there
            // is no need to call it. Implicitly defined destructor is trivial, because
            // both members (bool and union containing only variants which are trivially
            // destructible) are trivially destructible.
            // Explicitly-defaulted destructor is also trivial, but do not use it here,
            // because it hides the implicit move constructor. It is needed to implement
            // constexpr move constructor in OptionalStorage iff T is trivially move
            // constructible. Note that, if T is trivially move constructible, the move
            // constructor of OptionalStorageBase<T> is also implicitly defined and it is
            // trivially move constructor. If T is not trivially move constructible,
            // "not declaring move constructor without destructor declaration" here means
            // "delete move constructor", which works because any move constructor of
            // OptionalStorage will not refer to it in that case.

            template <class... Args>
            void Init(Args&&... args)
            {
                DCHECK(!is_populated_);
                ::new (&value_) T(std::forward<Args>(args)...);
                is_populated_ = true;
            }

            bool is_populated_ = false;
            union {
                // |empty_| exists so that the union will always be initialized, even when
                // it doesn't contain a value. Union members must be initialized for the
                // constructor to be 'constexpr'.
                char empty_;
                T value_;
            };
        };

// Implement conditional constexpr copy and move constructors. These are
// constexpr if is_trivially_{copy,move}_constructible<T>::value is true
// respectively. If each is true, the corresponding constructor is defined as
// "= default;", which generates a constexpr constructor (In this case,
// the condition of constexpr-ness is satisfied because the base class also has
// compiler generated constexpr {copy,move} constructors). Note that
// placement-new is prohibited in constexpr.
#if defined(__GNUC__) && __GNUC__ < 5
// gcc <5 does not implement std::is_trivially_copy_constructible.
// Conservatively assume false for this configuration.
// TODO(clemensh): Remove this once we drop support for gcc <5.
#define TRIVIALLY_COPY_CONSTRUCTIBLE(T) false
#define TRIVIALLY_MOVE_CONSTRUCTIBLE(T) false
#else
#define TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
    std::is_trivially_copy_constructible<T>::value
#define TRIVIALLY_MOVE_CONSTRUCTIBLE(T) \
    std::is_trivially_move_constructible<T>::value
#endif
        template <typename T, bool = TRIVIALLY_COPY_CONSTRUCTIBLE(T),
            bool = TRIVIALLY_MOVE_CONSTRUCTIBLE(T)>
#undef TRIVIALLY_COPY_CONSTRUCTIBLE
        struct OptionalStorage : OptionalStorageBase<T> {
            // This is no trivially {copy,move} constructible case. Other cases are
            // defined below as specializations.

            // Accessing the members of template base class requires explicit
            // declaration.
            using OptionalStorageBase<T>::is_populated_;
            using OptionalStorageBase<T>::value_;
            using OptionalStorageBase<T>::Init;

            // Inherit constructors (specifically, the in_place constructor).
            using OptionalStorageBase<T>::OptionalStorageBase;

            // User defined constructor deletes the default constructor.
            // Define it explicitly.
            OptionalStorage() = default;

            OptionalStorage(const OptionalStorage& other) V8_NOEXCEPT
            {
                if (other.is_populated_)
                    Init(other.value_);
            }

            OptionalStorage(OptionalStorage&& other) V8_NOEXCEPT
            {
                if (other.is_populated_)
                    Init(std::move(other.value_));
            }
        };

        template <typename T>
        struct OptionalStorage<T, true /* trivially copy constructible */,
            false /* trivially move constructible */>
            : OptionalStorageBase<T> {
            using OptionalStorageBase<T>::is_populated_;
            using OptionalStorageBase<T>::value_;
            using OptionalStorageBase<T>::Init;
            using OptionalStorageBase<T>::OptionalStorageBase;

            OptionalStorage() = default;
            OptionalStorage(const OptionalStorage& other) V8_NOEXCEPT = default;

            OptionalStorage(OptionalStorage&& other) V8_NOEXCEPT
            {
                if (other.is_populated_)
                    Init(std::move(other.value_));
            }
        };

        template <typename T>
        struct OptionalStorage<T, false /* trivially copy constructible */,
            true /* trivially move constructible */>
            : OptionalStorageBase<T> {
            using OptionalStorageBase<T>::is_populated_;
            using OptionalStorageBase<T>::value_;
            using OptionalStorageBase<T>::Init;
            using OptionalStorageBase<T>::OptionalStorageBase;

            OptionalStorage() = default;
            OptionalStorage(OptionalStorage&& other) V8_NOEXCEPT = default;

            OptionalStorage(const OptionalStorage& other) V8_NOEXCEPT
            {
                if (other.is_populated_)
                    Init(other.value_);
            }
        };

        template <typename T>
        struct OptionalStorage<T, true /* trivially copy constructible */,
            true /* trivially move constructible */>
            : OptionalStorageBase<T> {
            // If both trivially {copy,move} constructible are true, it is not necessary
            // to use user-defined constructors. So, just inheriting constructors
            // from the base class works.
            using OptionalStorageBase<T>::OptionalStorageBase;
        };

        // Base class to support conditionally usable copy-/move- constructors
        // and assign operators.
        template <typename T>
        class OptionalBase {
            // This class provides implementation rather than public API, so everything
            // should be hidden. Often we use composition, but we cannot in this case
            // because of C++ language restriction.
        protected:
            constexpr OptionalBase() = default;
            constexpr OptionalBase(const OptionalBase& other) V8_NOEXCEPT = default;
            constexpr OptionalBase(OptionalBase&& other) V8_NOEXCEPT = default;

            template <class... Args>
            constexpr explicit OptionalBase(in_place_t, Args&&... args)
                : storage_(in_place, std::forward<Args>(args)...)
            {
            }

            // Implementation of converting constructors.
            template <typename U>
            explicit OptionalBase(const OptionalBase<U>& other) V8_NOEXCEPT
            {
                if (other.storage_.is_populated_)
                    storage_.Init(other.storage_.value_);
            }

            template <typename U>
            explicit OptionalBase(OptionalBase<U>&& other) V8_NOEXCEPT
            {
                if (other.storage_.is_populated_)
                    storage_.Init(std::move(other.storage_.value_));
            }

            ~OptionalBase() = default;

            OptionalBase& operator=(const OptionalBase& other) V8_NOEXCEPT
            {
                CopyAssign(other);
                return *this;
            }

            OptionalBase& operator=(OptionalBase&& other) V8_NOEXCEPT
            {
                MoveAssign(std::move(other));
                return *this;
            }

            template <typename U>
            void CopyAssign(const OptionalBase<U>& other)
            {
                if (other.storage_.is_populated_)
                    InitOrAssign(other.storage_.value_);
                else
                    FreeIfNeeded();
            }

            template <typename U>
            void MoveAssign(OptionalBase<U>&& other)
            {
                if (other.storage_.is_populated_)
                    InitOrAssign(std::move(other.storage_.value_));
                else
                    FreeIfNeeded();
            }

            template <typename U>
            void InitOrAssign(U&& value)
            {
                if (storage_.is_populated_)
                    storage_.value_ = std::forward<U>(value);
                else
                    storage_.Init(std::forward<U>(value));
            }

            void FreeIfNeeded()
            {
                if (!storage_.is_populated_)
                    return;
                storage_.value_.~T();
                storage_.is_populated_ = false;
            }

            // For implementing conversion, allow access to other typed OptionalBase
            // class.
            template <typename U>
            friend class OptionalBase;

            OptionalStorage<T> storage_;
        };

        // The following {Copy,Move}{Constructible,Assignable} structs are helpers to
        // implement constructor/assign-operator overloading. Specifically, if T is
        // is not movable but copyable, Optional<T>'s move constructor should not
        // participate in overload resolution. This inheritance trick implements that.
        template <bool is_copy_constructible>
        struct CopyConstructible {
        };

        template <>
        struct CopyConstructible<false> {
            constexpr CopyConstructible() = default;
            constexpr CopyConstructible(const CopyConstructible&) V8_NOEXCEPT = delete;
            constexpr CopyConstructible(CopyConstructible&&) V8_NOEXCEPT = default;
            CopyConstructible& operator=(const CopyConstructible&) V8_NOEXCEPT = default;
            CopyConstructible& operator=(CopyConstructible&&) V8_NOEXCEPT = default;
        };

        template <bool is_move_constructible>
        struct MoveConstructible {
        };

        template <>
        struct MoveConstructible<false> {
            constexpr MoveConstructible() = default;
            constexpr MoveConstructible(const MoveConstructible&) V8_NOEXCEPT = default;
            constexpr MoveConstructible(MoveConstructible&&) V8_NOEXCEPT = delete;
            MoveConstructible& operator=(const MoveConstructible&) V8_NOEXCEPT = default;
            MoveConstructible& operator=(MoveConstructible&&) V8_NOEXCEPT = default;
        };

        template <bool is_copy_assignable>
        struct CopyAssignable {
        };

        template <>
        struct CopyAssignable<false> {
            constexpr CopyAssignable() = default;
            constexpr CopyAssignable(const CopyAssignable&) V8_NOEXCEPT = default;
            constexpr CopyAssignable(CopyAssignable&&) V8_NOEXCEPT = default;
            CopyAssignable& operator=(const CopyAssignable&) V8_NOEXCEPT = delete;
            CopyAssignable& operator=(CopyAssignable&&) V8_NOEXCEPT = default;
        };

        template <bool is_move_assignable>
        struct MoveAssignable {
        };

        template <>
        struct MoveAssignable<false> {
            constexpr MoveAssignable() = default;
            constexpr MoveAssignable(const MoveAssignable&) V8_NOEXCEPT = default;
            constexpr MoveAssignable(MoveAssignable&&) V8_NOEXCEPT = default;
            MoveAssignable& operator=(const MoveAssignable&) V8_NOEXCEPT = default;
            MoveAssignable& operator=(MoveAssignable&&) V8_NOEXCEPT = delete;
        };

        // Helper to conditionally enable converting constructors and assign operators.
        template <typename T, typename U>
        struct IsConvertibleFromOptional
            : std::integral_constant<
                  bool, std::is_constructible<T, Optional<U>&>::value || std::is_constructible<T, const Optional<U>&>::value || std::is_constructible<T, Optional<U>&&>::value || std::is_constructible<T, const Optional<U>&&>::value || std::is_convertible<Optional<U>&, T>::value || std::is_convertible<const Optional<U>&, T>::value || std::is_convertible<Optional<U>&&, T>::value || std::is_convertible<const Optional<U>&&, T>::value> {
        };

        template <typename T, typename U>
        struct IsAssignableFromOptional
            : std::integral_constant<
                  bool, IsConvertibleFromOptional<T, U>::value || std::is_assignable<T&, Optional<U>&>::value || std::is_assignable<T&, const Optional<U>&>::value || std::is_assignable<T&, Optional<U>&&>::value || std::is_assignable<T&, const Optional<U>&&>::value> {
        };

        // Forward compatibility for C++17.
        // Introduce one more deeper nested namespace to avoid leaking using std::swap.
        namespace swappable_impl {
            using std::swap;

            struct IsSwappableImpl {
                // Tests if swap can be called. Check<T&>(0) returns true_type iff swap
                // is available for T. Otherwise, Check's overload resolution falls back
                // to Check(...) declared below thanks to SFINAE, so returns false_type.
                template <typename T>
                static auto Check(int i)
                    -> decltype(swap(std::declval<T>(), std::declval<T>()), std::true_type());

                template <typename T>
                static std::false_type Check(...);
            };
        } // namespace swappable_impl

        template <typename T>
        struct IsSwappable : decltype(swappable_impl::IsSwappableImpl::Check<T&>(0)) {
        };

        // Forward compatibility for C++20.
        template <typename T>
        using RemoveCvRefT =
            typename std::remove_cv<typename std::remove_reference<T>::type>::type;

    } // namespace internal

// On Windows, by default, empty-base class optimization does not work,
// which means even if the base class is empty struct, it still consumes one
// byte for its body. __declspec(empty_bases) enables the optimization.
// cf)
// https://blogs.msdn.microsoft.com/vcblog/2016/03/30/optimizing-the-layout-of-empty-base-classes-in-vs2015-update-2-3/
#ifdef OS_WIN
#define OPTIONAL_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
#else
#define OPTIONAL_DECLSPEC_EMPTY_BASES
#endif

    // base::Optional is a Chromium version of the C++17 optional class:
    // std::optional documentation:
    // http://en.cppreference.com/w/cpp/utility/optional
    // Chromium documentation:
    // https://chromium.googlesource.com/chromium/src/+/master/docs/optional.md
    //
    // These are the differences between the specification and the implementation:
    // - Constructors do not use 'constexpr' as it is a C++14 extension.
    // - 'constexpr' might be missing in some places for reasons specified locally.
    // - No exceptions are thrown, because they are banned from Chromium.
    //   All copy/move constructors or assignment operators are marked V8_NOEXCEPT.
    // - All the non-members are in the 'base' namespace instead of 'std'.
    //
    // Note that T cannot have a constructor T(Optional<T>) etc. Optional<T> checks
    // T's constructor (specifically via IsConvertibleFromOptional), and in the
    // check whether T can be constructible from Optional<T>, which is recursive
    // so it does not work. As of Feb 2018, std::optional C++17 implementation in
    // both clang and gcc has same limitation. MSVC SFINAE looks to have different
    // behavior, but anyway it reports an error, too.
    template <typename T>
    class OPTIONAL_DECLSPEC_EMPTY_BASES Optional
        : public internal::OptionalBase<T>,
          public internal::CopyConstructible<std::is_copy_constructible<T>::value>,
          public internal::MoveConstructible<std::is_move_constructible<T>::value>,
          public internal::CopyAssignable<std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value>,
          public internal::MoveAssignable<std::is_move_constructible<T>::value && std::is_move_assignable<T>::value> {
    public:
#undef OPTIONAL_DECLSPEC_EMPTY_BASES
        using value_type = T;

        // Defer default/copy/move constructor implementation to OptionalBase.
        constexpr Optional() = default;
        constexpr Optional(const Optional& other) V8_NOEXCEPT = default;
        constexpr Optional(Optional&& other) V8_NOEXCEPT = default;

        constexpr Optional(nullopt_t) { } // NOLINT(runtime/explicit)

        // Converting copy constructor. "explicit" only if
        // std::is_convertible<const U&, T>::value is false. It is implemented by
        // declaring two almost same constructors, but that condition in enable_if
        // is different, so that either one is chosen, thanks to SFINAE.
        template <typename U,
            typename std::enable_if<
                std::is_constructible<T, const U&>::value && !internal::IsConvertibleFromOptional<T, U>::value && std::is_convertible<const U&, T>::value,
                bool>::type
            = false>
        Optional(const Optional<U>& other) V8_NOEXCEPT
            : internal::OptionalBase<T>(other) { }

        template <typename U,
            typename std::enable_if<
                std::is_constructible<T, const U&>::value && !internal::IsConvertibleFromOptional<T, U>::value && !std::is_convertible<const U&, T>::value,
                bool>::type
            = false>
        explicit Optional(const Optional<U>& other) V8_NOEXCEPT
            : internal::OptionalBase<T>(other) { }

        // Converting move constructor. Similar to converting copy constructor,
        // declaring two (explicit and non-explicit) constructors.
        template <typename U,
            typename std::enable_if<
                std::is_constructible<T, U&&>::value && !internal::IsConvertibleFromOptional<T, U>::value && std::is_convertible<U&&, T>::value,
                bool>::type
            = false>
        Optional(Optional<U>&& other) V8_NOEXCEPT
            : internal::OptionalBase<T>(std::move(other)) { }

        template <typename U,
            typename std::enable_if<
                std::is_constructible<T, U&&>::value && !internal::IsConvertibleFromOptional<T, U>::value && !std::is_convertible<U&&, T>::value,
                bool>::type
            = false>
        explicit Optional(Optional<U>&& other) V8_NOEXCEPT
            : internal::OptionalBase<T>(std::move(other)) { }

        template <class... Args>
        constexpr explicit Optional(in_place_t, Args&&... args)
            : internal::OptionalBase<T>(in_place, std::forward<Args>(args)...)
        {
        }

        template <class U, class... Args,
            class = typename std::enable_if<std::is_constructible<
                value_type, std::initializer_list<U>&, Args...>::value>::type>
        constexpr explicit Optional(in_place_t, std::initializer_list<U> il,
            Args&&... args)
            : internal::OptionalBase<T>(in_place, il, std::forward<Args>(args)...)
        {
        }

        // Forward value constructor. Similar to converting constructors,
        // conditionally explicit.
        template <
            typename U = value_type,
            typename std::enable_if<
                std::is_constructible<T, U&&>::value && !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value && !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value && std::is_convertible<U&&, T>::value,
                bool>::type
            = false>
        constexpr Optional(U&& value) // NOLINT(runtime/explicit)
            : internal::OptionalBase<T>(in_place, std::forward<U>(value))
        {
        }

        template <
            typename U = value_type,
            typename std::enable_if<
                std::is_constructible<T, U&&>::value && !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value && !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value && !std::is_convertible<U&&, T>::value,
                bool>::type
            = false>
        constexpr explicit Optional(U&& value)
            : internal::OptionalBase<T>(in_place, std::forward<U>(value))
        {
        }

        ~Optional() = default;

        // Defer copy-/move- assign operator implementation to OptionalBase.
        Optional& operator=(const Optional& other) V8_NOEXCEPT = default;
        Optional& operator=(Optional&& other) V8_NOEXCEPT = default;

        Optional& operator=(nullopt_t)
        {
            FreeIfNeeded();
            return *this;
        }

        // Perfect-forwarded assignment.
        template <typename U>
        typename std::enable_if<
            !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value && std::is_constructible<T, U>::value && std::is_assignable<T&, U>::value && (!std::is_scalar<T>::value || !std::is_same<typename std::decay<U>::type, T>::value),
            Optional&>::type
        operator=(U&& value) V8_NOEXCEPT
        {
            InitOrAssign(std::forward<U>(value));
            return *this;
        }

        // Copy assign the state of other.
        template <typename U>
        typename std::enable_if<!internal::IsAssignableFromOptional<T, U>::value && std::is_constructible<T, const U&>::value && std::is_assignable<T&, const U&>::value,
            Optional&>::type
        operator=(const Optional<U>& other) V8_NOEXCEPT
        {
            CopyAssign(other);
            return *this;
        }

        // Move assign the state of other.
        template <typename U>
        typename std::enable_if<!internal::IsAssignableFromOptional<T, U>::value && std::is_constructible<T, U>::value && std::is_assignable<T&, U>::value,
            Optional&>::type
        operator=(Optional<U>&& other) V8_NOEXCEPT
        {
            MoveAssign(std::move(other));
            return *this;
        }

        const T* operator->() const
        {
            DCHECK(storage_.is_populated_);
            return &storage_.value_;
        }

        T* operator->()
        {
            DCHECK(storage_.is_populated_);
            return &storage_.value_;
        }

        const T& operator*() const&
        {
            DCHECK(storage_.is_populated_);
            return storage_.value_;
        }

        T& operator*() &
        {
            DCHECK(storage_.is_populated_);
            return storage_.value_;
        }

        const T&& operator*() const&&
        {
            DCHECK(storage_.is_populated_);
            return std::move(storage_.value_);
        }

        T&& operator*() &&
        {
            DCHECK(storage_.is_populated_);
            return std::move(storage_.value_);
        }

        constexpr explicit operator bool() const { return storage_.is_populated_; }

        constexpr bool has_value() const { return storage_.is_populated_; }

        T& value() &
        {
            CHECK(storage_.is_populated_);
            return storage_.value_;
        }

        const T& value() const&
        {
            CHECK(storage_.is_populated_);
            return storage_.value_;
        }

        T&& value() &&
        {
            CHECK(storage_.is_populated_);
            return std::move(storage_.value_);
        }

        const T&& value() const&&
        {
            CHECK(storage_.is_populated_);
            return std::move(storage_.value_);
        }

        template <class U>
        constexpr T value_or(U&& default_value) const&
        {
            // TODO(mlamouri): add the following assert when possible:
            // static_assert(std::is_copy_constructible<T>::value,
            //               "T must be copy constructible");
            static_assert(std::is_convertible<U, T>::value,
                "U must be convertible to T");
            return storage_.is_populated_
                ? storage_.value_
                : static_cast<T>(std::forward<U>(default_value));
        }

        template <class U>
        T value_or(U&& default_value) &&
        {
            // TODO(mlamouri): add the following assert when possible:
            // static_assert(std::is_move_constructible<T>::value,
            //               "T must be move constructible");
            static_assert(std::is_convertible<U, T>::value,
                "U must be convertible to T");
            return storage_.is_populated_
                ? std::move(storage_.value_)
                : static_cast<T>(std::forward<U>(default_value));
        }

        void swap(Optional& other)
        {
            if (!storage_.is_populated_ && !other.storage_.is_populated_)
                return;

            if (storage_.is_populated_ != other.storage_.is_populated_) {
                if (storage_.is_populated_) {
                    other.storage_.Init(std::move(storage_.value_));
                    FreeIfNeeded();
                } else {
                    storage_.Init(std::move(other.storage_.value_));
                    other.FreeIfNeeded();
                }
                return;
            }

            DCHECK(storage_.is_populated_ && other.storage_.is_populated_);
            using std::swap;
            swap(**this, *other);
        }

        void reset() { FreeIfNeeded(); }

        template <class... Args>
        T& emplace(Args&&... args)
        {
            FreeIfNeeded();
            storage_.Init(std::forward<Args>(args)...);
            return storage_.value_;
        }

        template <class U, class... Args>
        typename std::enable_if<
            std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
            T&>::type
        emplace(std::initializer_list<U> il, Args&&... args)
        {
            FreeIfNeeded();
            storage_.Init(il, std::forward<Args>(args)...);
            return storage_.value_;
        }

    private:
        // Accessing template base class's protected member needs explicit
        // declaration to do so.
        using internal::OptionalBase<T>::CopyAssign;
        using internal::OptionalBase<T>::FreeIfNeeded;
        using internal::OptionalBase<T>::InitOrAssign;
        using internal::OptionalBase<T>::MoveAssign;
        using internal::OptionalBase<T>::storage_;
    };

    // Here after defines comparation operators. The definition follows
    // http://en.cppreference.com/w/cpp/utility/optional/operator_cmp
    // while bool() casting is replaced by has_value() to meet the chromium
    // style guide.
    template <class T, class U>
    bool operator==(const Optional<T>& lhs, const Optional<U>& rhs)
    {
        if (lhs.has_value() != rhs.has_value())
            return false;
        if (!lhs.has_value())
            return true;
        return *lhs == *rhs;
    }

    template <class T, class U>
    bool operator!=(const Optional<T>& lhs, const Optional<U>& rhs)
    {
        if (lhs.has_value() != rhs.has_value())
            return true;
        if (!lhs.has_value())
            return false;
        return *lhs != *rhs;
    }

    template <class T, class U>
    bool operator<(const Optional<T>& lhs, const Optional<U>& rhs)
    {
        if (!rhs.has_value())
            return false;
        if (!lhs.has_value())
            return true;
        return *lhs < *rhs;
    }

    template <class T, class U>
    bool operator<=(const Optional<T>& lhs, const Optional<U>& rhs)
    {
        if (!lhs.has_value())
            return true;
        if (!rhs.has_value())
            return false;
        return *lhs <= *rhs;
    }

    template <class T, class U>
    bool operator>(const Optional<T>& lhs, const Optional<U>& rhs)
    {
        if (!lhs.has_value())
            return false;
        if (!rhs.has_value())
            return true;
        return *lhs > *rhs;
    }

    template <class T, class U>
    bool operator>=(const Optional<T>& lhs, const Optional<U>& rhs)
    {
        if (!rhs.has_value())
            return true;
        if (!lhs.has_value())
            return false;
        return *lhs >= *rhs;
    }

    template <class T>
    constexpr bool operator==(const Optional<T>& opt, nullopt_t)
    {
        return !opt;
    }

    template <class T>
    constexpr bool operator==(nullopt_t, const Optional<T>& opt)
    {
        return !opt;
    }

    template <class T>
    constexpr bool operator!=(const Optional<T>& opt, nullopt_t)
    {
        return opt.has_value();
    }

    template <class T>
    constexpr bool operator!=(nullopt_t, const Optional<T>& opt)
    {
        return opt.has_value();
    }

    template <class T>
    constexpr bool operator<(const Optional<T>& opt, nullopt_t)
    {
        return false;
    }

    template <class T>
    constexpr bool operator<(nullopt_t, const Optional<T>& opt)
    {
        return opt.has_value();
    }

    template <class T>
    constexpr bool operator<=(const Optional<T>& opt, nullopt_t)
    {
        return !opt;
    }

    template <class T>
    constexpr bool operator<=(nullopt_t, const Optional<T>& opt)
    {
        return true;
    }

    template <class T>
    constexpr bool operator>(const Optional<T>& opt, nullopt_t)
    {
        return opt.has_value();
    }

    template <class T>
    constexpr bool operator>(nullopt_t, const Optional<T>& opt)
    {
        return false;
    }

    template <class T>
    constexpr bool operator>=(const Optional<T>& opt, nullopt_t)
    {
        return true;
    }

    template <class T>
    constexpr bool operator>=(nullopt_t, const Optional<T>& opt)
    {
        return !opt;
    }

    template <class T, class U>
    constexpr bool operator==(const Optional<T>& opt, const U& value)
    {
        return opt.has_value() ? *opt == value : false;
    }

    template <class T, class U>
    constexpr bool operator==(const U& value, const Optional<T>& opt)
    {
        return opt.has_value() ? value == *opt : false;
    }

    template <class T, class U>
    constexpr bool operator!=(const Optional<T>& opt, const U& value)
    {
        return opt.has_value() ? *opt != value : true;
    }

    template <class T, class U>
    constexpr bool operator!=(const U& value, const Optional<T>& opt)
    {
        return opt.has_value() ? value != *opt : true;
    }

    template <class T, class U>
    constexpr bool operator<(const Optional<T>& opt, const U& value)
    {
        return opt.has_value() ? *opt < value : true;
    }

    template <class T, class U>
    constexpr bool operator<(const U& value, const Optional<T>& opt)
    {
        return opt.has_value() ? value < *opt : false;
    }

    template <class T, class U>
    constexpr bool operator<=(const Optional<T>& opt, const U& value)
    {
        return opt.has_value() ? *opt <= value : true;
    }

    template <class T, class U>
    constexpr bool operator<=(const U& value, const Optional<T>& opt)
    {
        return opt.has_value() ? value <= *opt : false;
    }

    template <class T, class U>
    constexpr bool operator>(const Optional<T>& opt, const U& value)
    {
        return opt.has_value() ? *opt > value : false;
    }

    template <class T, class U>
    constexpr bool operator>(const U& value, const Optional<T>& opt)
    {
        return opt.has_value() ? value > *opt : true;
    }

    template <class T, class U>
    constexpr bool operator>=(const Optional<T>& opt, const U& value)
    {
        return opt.has_value() ? *opt >= value : false;
    }

    template <class T, class U>
    constexpr bool operator>=(const U& value, const Optional<T>& opt)
    {
        return opt.has_value() ? value >= *opt : true;
    }

    template <class T>
    constexpr Optional<typename std::decay<T>::type> make_optional(T&& value)
    {
        return Optional<typename std::decay<T>::type>(std::forward<T>(value));
    }

    template <class T, class... Args>
    constexpr Optional<T> make_optional(Args&&... args)
    {
        return Optional<T>(in_place, std::forward<Args>(args)...);
    }

    template <class T, class U, class... Args>
    constexpr Optional<T> make_optional(std::initializer_list<U> il,
        Args&&... args)
    {
        return Optional<T>(in_place, il, std::forward<Args>(args)...);
    }

    // Partial specialization for a function template is not allowed. Also, it is
    // not allowed to add overload function to std namespace, while it is allowed
    // to specialize the template in std. Thus, swap() (kind of) overloading is
    // defined in base namespace, instead.
    template <class T>
    typename std::enable_if<std::is_move_constructible<T>::value && internal::IsSwappable<T>::value>::type
    swap(Optional<T>& lhs, Optional<T>& rhs)
    {
        lhs.swap(rhs);
    }

} // namespace base
} // namespace v8

#endif // V8_BASE_OPTIONAL_H_
